package com.localShare.activity;


import android.app.AlertDialog;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.localShare.Common;
import com.localShare.Constant;
import com.localShare.manager.LockScreenManager;
import com.localShare.R;
import com.localShare.manager.ServiceManager;
import com.localShare.prompt.Prompt;
import com.nostra13.universalimageloader.cache.disc.naming.Md5FileNameGenerator;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
import com.nostra13.universalimageloader.core.assist.QueueProcessingType;
import com.util.IntentUtil;
import com.util.SharedPreferencesUtil;
import com.util.WindowManagerUtil;

/**
 * 程序入口类，各Activity根据不同的Intent从此处分流
 */
public class EntryActivity extends BaseActivity{
    //Intent工具类
    private final IntentUtil intentUtil=new IntentUtil();
    //WindowManager工具类
    private final WindowManagerUtil windowManagerUtil=new WindowManagerUtil();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //锁屏时也可显示
        windowManagerUtil.showWhenLocked(this);
        //加载布局
        setContentView(R.layout.activity_main);
        //全屏
        windowManagerUtil.fullScreen(this);
        //universal-image-loader初始化
        initImageLoader(this);
        //开启后台服务
        new ServiceManager().startService(this);
        //获取Intent
        Intent intent=getIntent();
        //获取action
        String action=intent.getAction();
        //若action不为空，则根据不同的action进行处理
        if(null!=action){
            switch(action){
                case Intent.ACTION_SEND:
                case Intent.ACTION_SEND_MULTIPLE:
                    //锁屏管理类
                    LockScreenManager lockScreenManager=new LockScreenManager(this);
                    //若有锁屏权限，则锁屏，然后处理后续动作
                    if(lockScreenManager.canLock()){
                        lockScreenManager.lock();
                        dealAfterLock(action,intent);
                    //若没有锁屏权限，则申请锁屏权限，同时临时保存当前数据，待有了锁屏权限后继续
                    }else{
                        Common.entryActivity=this;
                        Common.action=action;
                        Common.intent=intent;
                        //授权失败第一步
                        Common.simulationAuthorizationFailFlag=Constant.SIMULATION_AUTHORIZATION_FAIL_FIRST_STEP;
                        lockScreenManager.permissionRequest();
                    }
                    break;
                default:
                    //判断程序上次的加载内容，加载同样的内容
                    SharedPreferencesUtil sharedPreferencesUtil=new SharedPreferencesUtil();
                    int lastLoadFlag=sharedPreferencesUtil.getInt(this,Constant.PRIVATE_SHARED_PREFERENCE,Constant.LAST_LOAD_FLAG,Constant.LAST_LOAD_INIT);
                    switch (lastLoadFlag){
                        //初始状态，空执行
                        case Constant.LAST_LOAD_INIT:
                            break;
                        //加载单张图片
                        case Constant.LAST_LOAD_SINGLE_IMAGE:
                            loadHistorySingleImageDeal();
                            break;
                        //加载多张图片
                        case Constant.LAST_LOAD_MULTIPLE_IMAGE:
                            loadHistoryMultipleImageDeal();
                            break;
                        //加载视频
                        case Constant.LAST_LOAD_VIDEO:
                            loadHistoryVideoDeal();
                            break;
                    }
                    break;
            }
        }
    }

    /**
     * 模拟授权失败时的操作
     */
    @Override
    protected void onResume() {
        //根据当前授权失败模拟步数，做相应操作
        switch(Common.simulationAuthorizationFailFlag){
            //走到了第一步，续上第二步
            case Constant.SIMULATION_AUTHORIZATION_FAIL_FIRST_STEP:
                Common.simulationAuthorizationFailFlag=Constant.SIMULATION_AUTHORIZATION_FAIL_SECOND_STEP;
                break;
            //走到了第三步，授权失败模拟结束，调用授权失败的方法
            case Constant.SIMULATION_AUTHORIZATION_FAIL_THIRD_STEP:
                //授权失败模拟步骤归位
                Common.simulationAuthorizationFailFlag=Constant.SIMULATION_AUTHORIZATION_FAIL_INIT;
                //新建提示类
                Prompt prompt=new Prompt();
                //显示授权失败提示
                prompt.authorizationFailPrompt(this);
                break;
            //非一气呵成，则归位
            default:
                Common.simulationAuthorizationFailFlag=Constant.SIMULATION_AUTHORIZATION_FAIL_INIT;
                break;
        }
        super.onResume();
    }

    /**
     * 模拟授权失败
     */
    @Override
    protected void onPause() {
        switch(Common.simulationAuthorizationFailFlag){
            //走到第二步，续上第三步
            case Constant.SIMULATION_AUTHORIZATION_FAIL_SECOND_STEP:
                Common.simulationAuthorizationFailFlag=Constant.SIMULATION_AUTHORIZATION_FAIL_THIRD_STEP;
                break;
            //非一气呵成，归位
            default:
                Common.simulationAuthorizationFailFlag=Constant.SIMULATION_AUTHORIZATION_FAIL_INIT;
                break;
        }
        super.onPause();
    }

    /**
     * Universal-Image-loader框架初始化方法，来自其Demo。在其Demo中此操作位于Application中
     * @param context 上下文
     */
    private void initImageLoader(Context context) {
        // This configuration tuning is custom. You can tune every option, you may tune some of them,
        // or you can create default configuration by
        //  ImageLoaderConfiguration.createDefault(this);
        // method.
        ImageLoaderConfiguration.Builder config = new ImageLoaderConfiguration.Builder(context);
        config.threadPriority(Thread.NORM_PRIORITY - 2);
        config.denyCacheImageMultipleSizesInMemory();
        config.diskCacheFileNameGenerator(new Md5FileNameGenerator());
        config.diskCacheSize(50 * 1024 * 1024); // 50 MiB
        config.tasksProcessingOrder(QueueProcessingType.LIFO);
        config.writeDebugLogs(); // Remove for release app

        // Initialize ImageLoader with configuration.
        ImageLoader.getInstance().init(config.build());
    }

    /**
     * 主动发起锁屏后的动作处理
     * @param action 意图中带的action
     * @param intent 意图
     */
    public void dealAfterLock(String action,Intent intent){
        //根据不同的action进行不同的操作
        switch(action){
            case Intent.ACTION_SEND:
                actionSendDeal(intent);
                break;
            case Intent.ACTION_SEND_MULTIPLE:
                actionSendMultipleDeal(intent);
                break;
        }
    }
    /**
     * 当action为Intent.ACTION_SEND时的处理方法
     * @param intent 启动此Activity的意图
     */
    private void actionSendDeal(Intent intent){
        //获取数据类型
        String dataType=intent.getType();
        //如果数据类型不为空时，根据不同的数据类型，采取不同的操作
        if(!Constant.DATA_TYPE_INIT.equals(dataType)){
            switch(dataType){
                //数据类型为image/*
                case Constant.DATA_TYPE_IMAGE:
                    actionSendAndImageDeal(intent);
                    break;
                //数据类型为video/*
                case Constant.DATA_TYPE_VIDEO:
                    actionSendAndVideoDeal(intent);
                    break;
            }
        }
    }

    /**
     * 当action为Intent.ACTION_SEND
     * 数据类型为image/*时的处理方法
     * @param intent 启动当前Activity的意图
     */
    private void actionSendAndImageDeal(Intent intent){
        //打开加载单张图片的Activity
        startDataDisplayActivityFromIntent(intent,SingleImageActivity.class);
    }

    /**
     * 当action为Intent.ACTION_SEND
     * 数据类型为video/*时的处理方法
     * @param intent 启动当前Activity的意图
     */
    private void actionSendAndVideoDeal(Intent intent){
        //打开播放视频的Activity
        startDataDisplayActivityFromIntent(intent,VideoActivity.class);
    }

    /**
     * 当action为Intent.ACTION_SEND_MULTIPLE时的处理方法
     * @param intent 启动当前Activity的意图
     */
    private void actionSendMultipleDeal(Intent intent){
        //打开加载多张图片的Activity
        startDataDisplayActivityFromIntent(intent,MultipleImageActivity.class);
    }
    /**
     * 启动数据显示activity，从Intent中获取数据
     * @param intent 当前activity的意图
     * @param targetClass  目标Activity的Class
     */
    private void startDataDisplayActivityFromIntent(Intent intent,Class targetClass){
        //创建意图
        Intent newIntent=new Intent(this,targetClass);
        //设置标识，从当前Intent取数据
        newIntent.setFlags(Constant.COM_FROM_CURRENT);
        //数据拷贝至新意图
        intentUtil.copyExtras(intent,newIntent);
        //启动目标Activity
        startActivity(newIntent);
        //当前Activity关闭
        this.finish();
    }
    /**
     * 启动数据显示activity，从历史记录获取数据
     * @param targetClass 目标Activity的Class
     */
    private void startDataDisplayActivityFromHistory(Class targetClass){
        //创建意图
        Intent newIntent=new Intent(this,targetClass);
        //设置标识，从历史记录数据
        newIntent.setFlags(Constant.COM_FROM_HISTORY);
        //启动目标Activity
        startActivity(newIntent);
        //当前Activity关闭
        this.finish();
    }
    /**
     * 加载历史单张图片的处理方法
     */
    private void loadHistorySingleImageDeal(){
        //启动加载历史单张图片的Activity
        startDataDisplayActivityFromHistory(SingleImageActivity.class);
    }
    /**
     * 加载历史多张图片的处理方法
     */
    private void loadHistoryMultipleImageDeal(){
        //启动加载历史多张图片的Activity
        startDataDisplayActivityFromHistory(MultipleImageActivity.class);
    }
    /**
     * 加载历史视频的处理方法
     */
    private void loadHistoryVideoDeal(){
        //启动加载历史多张图片的Activity
        startDataDisplayActivityFromHistory(VideoActivity.class);
    }
}
